package com.ourteam.system.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-07-31 15:13:31
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class SysEventLogDAOQueryBean extends BaseQueryBean {
    public SysEventLogDAOQueryBean() {
        super();
    }

    public SysEventLogDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public SysEventLogDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.Id, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.Id, "id");
        }
    }

    public void addEventLevelSelectProperty() {
        addEventLevelSelectProperty("eventLevel");
    }

    public void addEventLevelSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventLevel, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventLevel, "eventLevel");
        }
    }

    public void addEventTypeIdSelectProperty() {
        addEventTypeIdSelectProperty("eventTypeId");
    }

    public void addEventTypeIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventTypeId, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventTypeId, "eventTypeId");
        }
    }

    public void addEventSourceSelectProperty() {
        addEventSourceSelectProperty("eventSource");
    }

    public void addEventSourceSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventSource, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventSource, "eventSource");
        }
    }

    public void addEventContentSelectProperty() {
        addEventContentSelectProperty("eventContent");
    }

    public void addEventContentSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventContent, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventContent, "eventContent");
        }
    }

    public void addEventTimeSelectProperty() {
        addEventTimeSelectProperty("eventTime");
    }

    public void addEventTimeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventTime, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventTime, "eventTime");
        }
    }

    public void addEventOperatorSelectProperty() {
        addEventOperatorSelectProperty("eventOperator");
    }

    public void addEventOperatorSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventOperator, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventOperator, "eventOperator");
        }
    }

    public void addEventOperatorIdSelectProperty() {
        addEventOperatorIdSelectProperty("eventOperatorId");
    }

    public void addEventOperatorIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventOperatorId, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventOperatorId, "eventOperatorId");
        }
    }

    public void addEventOperatorClientSelectProperty() {
        addEventOperatorClientSelectProperty("eventOperatorClient");
    }

    public void addEventOperatorClientSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventOperatorClient, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventOperatorClient,
                "eventOperatorClient");
        }
    }

    public void addEventDataSelectProperty() {
        addEventDataSelectProperty("eventData");
    }

    public void addEventDataSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventData, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventData, "eventData");
        }
    }

    public void addEventSourceIdSelectProperty() {
        addEventSourceIdSelectProperty("eventSourceId");
    }

    public void addEventSourceIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventSourceId, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventSourceId, "eventSourceId");
        }
    }

    public void addEventTypeCodeSelectProperty() {
        addEventTypeCodeSelectProperty("eventTypeCode");
    }

    public void addEventTypeCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventTypeCode, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventTypeCode, "eventTypeCode");
        }
    }

    public void addEventTypeNameSelectProperty() {
        addEventTypeNameSelectProperty("eventTypeName");
    }

    public void addEventTypeNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventTypeName, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventTypeName, "eventTypeName");
        }
    }

    public void addEventTypeStatusSelectProperty() {
        addEventTypeStatusSelectProperty("eventTypeStatus");
    }

    public void addEventTypeStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventTypeStatus, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventTypeStatus, "eventTypeStatus");
        }
    }

    public void addEventDomainIdSelectProperty() {
        addEventDomainIdSelectProperty("eventDomainId");
    }

    public void addEventDomainIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventDomainId, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventDomainId, "eventDomainId");
        }
    }

    public void addEventDomainCodeSelectProperty() {
        addEventDomainCodeSelectProperty("eventDomainCode");
    }

    public void addEventDomainCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.EventDomainCode, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.EventDomainCode, "eventDomainCode");
        }
    }

    public void addOperatorNameSelectProperty() {
        addOperatorNameSelectProperty("operatorName");
    }

    public void addOperatorNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(ISysEventLogDAO.OperatorName, aAlias);
        } else {
            addSelectProperty(ISysEventLogDAO.OperatorName, "operatorName");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addEventLevelSelectProperty();

        addEventTypeIdSelectProperty();

        addEventSourceSelectProperty();

        addEventContentSelectProperty();

        addEventTimeSelectProperty();

        addEventOperatorSelectProperty();

        addEventOperatorIdSelectProperty();

        addEventOperatorClientSelectProperty();

        addEventDataSelectProperty();

        addEventSourceIdSelectProperty();

        addEventTypeCodeSelectProperty();

        addEventTypeNameSelectProperty();

        addEventTypeStatusSelectProperty();

        addEventDomainIdSelectProperty();

        addEventDomainCodeSelectProperty();

        addOperatorNameSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<SysEventLogDAOQueryBean> {
        protected Criteria(SysEventLogDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(ISysEventLogDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(ISysEventLogDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(ISysEventLogDAO.Id + " is not null AND " +
                ISysEventLogDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.Id + " is null OR " +
                ISysEventLogDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " is null OR " +
                ISysEventLogDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.Id + " in", Arrays.asList(values),
                    "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.Id + " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.Id + " between", value1, value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.Id + " between", value1, value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.Id + " not between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.Id + " not between", value1, value2,
                "id");

            return this;
        }

        public Criteria andEventLevelIsNull() {
            addCriterion(ISysEventLogDAO.EventLevel + " is null");

            return this;
        }

        public Criteria andEventLevelIsNotNull() {
            addCriterion(ISysEventLogDAO.EventLevel + " is not null");

            return this;
        }

        public Criteria andEventLevelIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventLevel + " is not null AND " +
                ISysEventLogDAO.EventLevel + " <> ''");

            return this;
        }

        public Criteria andEventLevelIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventLevel + " is null OR " +
                ISysEventLogDAO.EventLevel + " = '')");

            return this;
        }

        public Criteria andEventLevelEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " = ", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " <>", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " is null OR " +
                ISysEventLogDAO.EventLevel + " <>", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " >", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " >=", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " <", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventLevel + " <=", value, "eventLevel");

            return this;
        }

        public Criteria andEventLevelLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventLevel);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventLevelLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventLevel + " like",
                buffer.toString(), "eventLevel");

            return this;
        }

        public Criteria andEventLevelNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventLevel + " not like",
                buffer.toString(), "eventLevel");

            return this;
        }

        public Criteria andEventLevelIn(List<String> values) {
            if (values.size() == 1) {
                return andEventLevelEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventLevel + " in", values,
                    "eventLevel");

                return this;
            }
        }

        public Criteria andEventLevelNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventLevelNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventLevel + " not in", values,
                    "eventLevel");

                return this;
            }
        }

        public Criteria andEventLevelIn(String[] values) {
            if (values.length == 1) {
                return andEventLevelEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventLevel + " in",
                    Arrays.asList(values), "eventLevel");

                return this;
            }
        }

        public Criteria andEventLevelNotIn(String[] values) {
            if (values.length == 1) {
                return andEventLevelNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventLevel + " not in",
                    Arrays.asList(values), "eventLevel");

                return this;
            }
        }

        public Criteria andEventLevelIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventLevelNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventLevel + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventLevelBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventLevel + " between", value1,
                value2, "eventLevel");

            return this;
        }

        public Criteria andEventLevelNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventLevel + " not between", value1,
                value2, "eventLevel");

            return this;
        }

        public Criteria andEventTypeIdIsNull() {
            addCriterion(ISysEventLogDAO.EventTypeId + " is null");

            return this;
        }

        public Criteria andEventTypeIdIsNotNull() {
            addCriterion(ISysEventLogDAO.EventTypeId + " is not null");

            return this;
        }

        public Criteria andEventTypeIdIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventTypeId + " is not null AND " +
                ISysEventLogDAO.EventTypeId + " <> ''");

            return this;
        }

        public Criteria andEventTypeIdIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventTypeId + " is null OR " +
                ISysEventLogDAO.EventTypeId + " = '')");

            return this;
        }

        public Criteria andEventTypeIdEqualTo(long value) {
            return andEventTypeIdEqualTo(Long.valueOf(value));
        }

        public Criteria andEventTypeIdEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " = ", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdNotEqualTo(long value) {
            return andEventTypeIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andEventTypeIdNotEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " <>", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdNotEqualToOrIsNull(long value) {
            return andEventTypeIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andEventTypeIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " is null OR " +
                ISysEventLogDAO.EventTypeId + " <>", value, "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdGreaterThan(long value) {
            return andEventTypeIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andEventTypeIdGreaterThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " >", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdGreaterThanOrEqualTo(long value) {
            return andEventTypeIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventTypeIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " >=", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdLessThan(long value) {
            return andEventTypeIdLessThan(Long.valueOf(value));
        }

        public Criteria andEventTypeIdLessThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " <", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdLessThanOrEqualTo(long value) {
            return andEventTypeIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventTypeIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventTypeId + " <=", value,
                "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdIn(long[] values) {
            if (values.length == 1) {
                return andEventTypeIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " in", values,
                    "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdNotIn(long[] values) {
            if (values.length == 1) {
                return andEventTypeIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " not in", values,
                    "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventTypeIdEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " in", values,
                    "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventTypeIdNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " not in", values,
                    "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventTypeIdEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " in",
                    Arrays.asList(values), "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventTypeIdNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeId + " not in",
                    Arrays.asList(values), "eventTypeId");

                return this;
            }
        }

        public Criteria andEventTypeIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeIdBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventTypeId + " between", value1,
                value2, "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventTypeId + " between", value1,
                value2, "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdNotBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventTypeId + " not between", value1,
                value2, "eventTypeId");

            return this;
        }

        public Criteria andEventTypeIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventTypeId + " not between", value1,
                value2, "eventTypeId");

            return this;
        }

        public Criteria andEventSourceIsNull() {
            addCriterion(ISysEventLogDAO.EventSource + " is null");

            return this;
        }

        public Criteria andEventSourceIsNotNull() {
            addCriterion(ISysEventLogDAO.EventSource + " is not null");

            return this;
        }

        public Criteria andEventSourceIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventSource + " is not null AND " +
                ISysEventLogDAO.EventSource + " <> ''");

            return this;
        }

        public Criteria andEventSourceIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventSource + " is null OR " +
                ISysEventLogDAO.EventSource + " = '')");

            return this;
        }

        public Criteria andEventSourceEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " = ", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " <>", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " is null OR " +
                ISysEventLogDAO.EventSource + " <>", value, "eventSource");

            return this;
        }

        public Criteria andEventSourceNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " >", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " >=", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " <", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventSource + " <=", value,
                "eventSource");

            return this;
        }

        public Criteria andEventSourceLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSource);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventSource + " like",
                buffer.toString(), "eventSource");

            return this;
        }

        public Criteria andEventSourceNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventSource + " not like",
                buffer.toString(), "eventSource");

            return this;
        }

        public Criteria andEventSourceIn(List<String> values) {
            if (values.size() == 1) {
                return andEventSourceEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventSource + " in", values,
                    "eventSource");

                return this;
            }
        }

        public Criteria andEventSourceNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventSourceNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventSource + " not in", values,
                    "eventSource");

                return this;
            }
        }

        public Criteria andEventSourceIn(String[] values) {
            if (values.length == 1) {
                return andEventSourceEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSource + " in",
                    Arrays.asList(values), "eventSource");

                return this;
            }
        }

        public Criteria andEventSourceNotIn(String[] values) {
            if (values.length == 1) {
                return andEventSourceNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSource + " not in",
                    Arrays.asList(values), "eventSource");

                return this;
            }
        }

        public Criteria andEventSourceIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSource + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventSource + " between", value1,
                value2, "eventSource");

            return this;
        }

        public Criteria andEventSourceNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventSource + " not between", value1,
                value2, "eventSource");

            return this;
        }

        public Criteria andEventContentIsNull() {
            addCriterion(ISysEventLogDAO.EventContent + " is null");

            return this;
        }

        public Criteria andEventContentIsNotNull() {
            addCriterion(ISysEventLogDAO.EventContent + " is not null");

            return this;
        }

        public Criteria andEventContentIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventContent + " is not null AND " +
                ISysEventLogDAO.EventContent + " <> ''");

            return this;
        }

        public Criteria andEventContentIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventContent + " is null OR " +
                ISysEventLogDAO.EventContent + " = '')");

            return this;
        }

        public Criteria andEventContentEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " = ", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventContentNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " <>", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " is null OR " +
                ISysEventLogDAO.EventContent + " <>", value, "eventContent");

            return this;
        }

        public Criteria andEventContentNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventContentGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " >", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventContentGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " >=", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventContentLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " <", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventContentLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventContent + " <=", value,
                "eventContent");

            return this;
        }

        public Criteria andEventContentLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventContent);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventContentLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventContentLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventContent + " like",
                buffer.toString(), "eventContent");

            return this;
        }

        public Criteria andEventContentNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventContent + " not like",
                buffer.toString(), "eventContent");

            return this;
        }

        public Criteria andEventContentIn(List<String> values) {
            if (values.size() == 1) {
                return andEventContentEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventContent + " in", values,
                    "eventContent");

                return this;
            }
        }

        public Criteria andEventContentNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventContentNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventContent + " not in", values,
                    "eventContent");

                return this;
            }
        }

        public Criteria andEventContentIn(String[] values) {
            if (values.length == 1) {
                return andEventContentEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventContent + " in",
                    Arrays.asList(values), "eventContent");

                return this;
            }
        }

        public Criteria andEventContentNotIn(String[] values) {
            if (values.length == 1) {
                return andEventContentNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventContent + " not in",
                    Arrays.asList(values), "eventContent");

                return this;
            }
        }

        public Criteria andEventContentIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventContentNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventContent + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventContentBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventContent + " between", value1,
                value2, "eventContent");

            return this;
        }

        public Criteria andEventContentNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventContent + " not between", value1,
                value2, "eventContent");

            return this;
        }

        public Criteria andEventTimeIsNull() {
            addCriterion(ISysEventLogDAO.EventTime + " is null");

            return this;
        }

        public Criteria andEventTimeIsNotNull() {
            addCriterion(ISysEventLogDAO.EventTime + " is not null");

            return this;
        }

        public Criteria andEventTimeIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventTime + " is not null AND " +
                ISysEventLogDAO.EventTime + " <> ''");

            return this;
        }

        public Criteria andEventTimeIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventTime + " is null OR " +
                ISysEventLogDAO.EventTime + " = '')");

            return this;
        }

        public Criteria andEventTimeEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " = ", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " <>", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " is null OR " +
                ISysEventLogDAO.EventTime + " <>", value, "eventTime");

            return this;
        }

        public Criteria andEventTimeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " >", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " >=", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeLessThan(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " <", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " <=", value,
                "eventTime");

            return this;
        }

        public Criteria andEventTimeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTime);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTimeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEventTimeEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " in",
                    values, "eventTime");

                return this;
            }
        }

        public Criteria andEventTimeNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEventTimeNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " not in",
                    values, "eventTime");

                return this;
            }
        }

        public Criteria andEventTimeIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEventTimeEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " in",
                    Arrays.asList(values), "eventTime");

                return this;
            }
        }

        public Criteria andEventTimeNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEventTimeNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " not in",
                    Arrays.asList(values), "eventTime");

                return this;
            }
        }

        public Criteria andEventTimeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventTimeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTime + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTimeBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " between",
                value1, value2, "eventTime");

            return this;
        }

        public Criteria andEventTimeNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(ISysEventLogDAO.EventTime + " not between",
                value1, value2, "eventTime");

            return this;
        }

        public Criteria andEventOperatorIsNull() {
            addCriterion(ISysEventLogDAO.EventOperator + " is null");

            return this;
        }

        public Criteria andEventOperatorIsNotNull() {
            addCriterion(ISysEventLogDAO.EventOperator + " is not null");

            return this;
        }

        public Criteria andEventOperatorIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventOperator + " is not null AND " +
                ISysEventLogDAO.EventOperator + " <> ''");

            return this;
        }

        public Criteria andEventOperatorIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventOperator + " is null OR " +
                ISysEventLogDAO.EventOperator + " = '')");

            return this;
        }

        public Criteria andEventOperatorEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " = ", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " <>", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " is null OR " +
                ISysEventLogDAO.EventOperator + " <>", value, "eventOperator");

            return this;
        }

        public Criteria andEventOperatorNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " >", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " >=", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " <", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperator + " <=", value,
                "eventOperator");

            return this;
        }

        public Criteria andEventOperatorLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperator);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventOperator + " like",
                buffer.toString(), "eventOperator");

            return this;
        }

        public Criteria andEventOperatorNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventOperator + " not like",
                buffer.toString(), "eventOperator");

            return this;
        }

        public Criteria andEventOperatorIn(List<String> values) {
            if (values.size() == 1) {
                return andEventOperatorEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperator + " in", values,
                    "eventOperator");

                return this;
            }
        }

        public Criteria andEventOperatorNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventOperatorNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperator + " not in", values,
                    "eventOperator");

                return this;
            }
        }

        public Criteria andEventOperatorIn(String[] values) {
            if (values.length == 1) {
                return andEventOperatorEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperator + " in",
                    Arrays.asList(values), "eventOperator");

                return this;
            }
        }

        public Criteria andEventOperatorNotIn(String[] values) {
            if (values.length == 1) {
                return andEventOperatorNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperator + " not in",
                    Arrays.asList(values), "eventOperator");

                return this;
            }
        }

        public Criteria andEventOperatorIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperator + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventOperator + " between", value1,
                value2, "eventOperator");

            return this;
        }

        public Criteria andEventOperatorNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventOperator + " not between",
                value1, value2, "eventOperator");

            return this;
        }

        public Criteria andEventOperatorIdIsNull() {
            addCriterion(ISysEventLogDAO.EventOperatorId + " is null");

            return this;
        }

        public Criteria andEventOperatorIdIsNotNull() {
            addCriterion(ISysEventLogDAO.EventOperatorId + " is not null");

            return this;
        }

        public Criteria andEventOperatorIdIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventOperatorId + " is not null AND " +
                ISysEventLogDAO.EventOperatorId + " <> ''");

            return this;
        }

        public Criteria andEventOperatorIdIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventOperatorId +
                " is null OR " + ISysEventLogDAO.EventOperatorId + " = '')");

            return this;
        }

        public Criteria andEventOperatorIdEqualTo(long value) {
            return andEventOperatorIdEqualTo(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " = ", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorIdNotEqualTo(long value) {
            return andEventOperatorIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdNotEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " <>", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdNotEqualToOrIsNull(long value) {
            return andEventOperatorIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " is null OR " +
                ISysEventLogDAO.EventOperatorId + " <>", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorIdGreaterThan(long value) {
            return andEventOperatorIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdGreaterThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " >", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorIdGreaterThanOrEqualTo(long value) {
            return andEventOperatorIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " >=", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorIdLessThan(long value) {
            return andEventOperatorIdLessThan(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdLessThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " <", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventOperatorIdLessThanOrEqualTo(long value) {
            return andEventOperatorIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventOperatorIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " <=", value,
                "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorIdIn(long[] values) {
            if (values.length == 1) {
                return andEventOperatorIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " in", values,
                    "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdNotIn(long[] values) {
            if (values.length == 1) {
                return andEventOperatorIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " not in",
                    values, "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventOperatorIdEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " in", values,
                    "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventOperatorIdNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " not in",
                    values, "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventOperatorIdEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " in",
                    Arrays.asList(values), "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventOperatorIdNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorId + " not in",
                    Arrays.asList(values), "eventOperatorId");

                return this;
            }
        }

        public Criteria andEventOperatorIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorIdBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " between", value1,
                value2, "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " between", value1,
                value2, "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdNotBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " not between",
                value1, value2, "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventOperatorId + " not between",
                value1, value2, "eventOperatorId");

            return this;
        }

        public Criteria andEventOperatorClientIsNull() {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " is null");

            return this;
        }

        public Criteria andEventOperatorClientIsNotNull() {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " is not null");

            return this;
        }

        public Criteria andEventOperatorClientIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventOperatorClient +
                " is not null AND " + ISysEventLogDAO.EventOperatorClient +
                " <> ''");

            return this;
        }

        public Criteria andEventOperatorClientIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventOperatorClient +
                " is null OR " + ISysEventLogDAO.EventOperatorClient +
                " = '')");

            return this;
        }

        public Criteria andEventOperatorClientEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " = ", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " <>", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " is null OR " +
                ISysEventLogDAO.EventOperatorClient + " <>", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " >", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " >=", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " <", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " <=", value,
                "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventOperatorClient);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventOperatorClientLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventOperatorClient + " like",
                buffer.toString(), "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventOperatorClient + " not like",
                buffer.toString(), "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientIn(List<String> values) {
            if (values.size() == 1) {
                return andEventOperatorClientEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorClient + " in",
                    values, "eventOperatorClient");

                return this;
            }
        }

        public Criteria andEventOperatorClientNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventOperatorClientNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorClient + " not in",
                    values, "eventOperatorClient");

                return this;
            }
        }

        public Criteria andEventOperatorClientIn(String[] values) {
            if (values.length == 1) {
                return andEventOperatorClientEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorClient + " in",
                    Arrays.asList(values), "eventOperatorClient");

                return this;
            }
        }

        public Criteria andEventOperatorClientNotIn(String[] values) {
            if (values.length == 1) {
                return andEventOperatorClientNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventOperatorClient + " not in",
                    Arrays.asList(values), "eventOperatorClient");

                return this;
            }
        }

        public Criteria andEventOperatorClientIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventOperatorClientBetween(String value1,
            String value2) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " between",
                value1, value2, "eventOperatorClient");

            return this;
        }

        public Criteria andEventOperatorClientNotBetween(String value1,
            String value2) {
            addCriterion(ISysEventLogDAO.EventOperatorClient + " not between",
                value1, value2, "eventOperatorClient");

            return this;
        }

        public Criteria andEventDataIsNull() {
            addCriterion(ISysEventLogDAO.EventData + " is null");

            return this;
        }

        public Criteria andEventDataIsNotNull() {
            addCriterion(ISysEventLogDAO.EventData + " is not null");

            return this;
        }

        public Criteria andEventDataIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventData + " is not null AND " +
                ISysEventLogDAO.EventData + " <> ''");

            return this;
        }

        public Criteria andEventDataIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventData + " is null OR " +
                ISysEventLogDAO.EventData + " = '')");

            return this;
        }

        public Criteria andEventDataEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventData + " = ", value, "eventData");

            return this;
        }

        public Criteria andEventDataEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventData + " <>", value, "eventData");

            return this;
        }

        public Criteria andEventDataNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventData + " is null OR " +
                ISysEventLogDAO.EventData + " <>", value, "eventData");

            return this;
        }

        public Criteria andEventDataNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventData + " >", value, "eventData");

            return this;
        }

        public Criteria andEventDataGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventData + " >=", value, "eventData");

            return this;
        }

        public Criteria andEventDataGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventData + " <", value, "eventData");

            return this;
        }

        public Criteria andEventDataLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventData + " <=", value, "eventData");

            return this;
        }

        public Criteria andEventDataLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventData);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDataLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventData + " like",
                buffer.toString(), "eventData");

            return this;
        }

        public Criteria andEventDataNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventData + " not like",
                buffer.toString(), "eventData");

            return this;
        }

        public Criteria andEventDataIn(List<String> values) {
            if (values.size() == 1) {
                return andEventDataEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventData + " in", values,
                    "eventData");

                return this;
            }
        }

        public Criteria andEventDataNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventDataNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventData + " not in", values,
                    "eventData");

                return this;
            }
        }

        public Criteria andEventDataIn(String[] values) {
            if (values.length == 1) {
                return andEventDataEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventData + " in",
                    Arrays.asList(values), "eventData");

                return this;
            }
        }

        public Criteria andEventDataNotIn(String[] values) {
            if (values.length == 1) {
                return andEventDataNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventData + " not in",
                    Arrays.asList(values), "eventData");

                return this;
            }
        }

        public Criteria andEventDataIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andEventDataNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventData + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDataBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventData + " between", value1,
                value2, "eventData");

            return this;
        }

        public Criteria andEventDataNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventData + " not between", value1,
                value2, "eventData");

            return this;
        }

        public Criteria andEventSourceIdIsNull() {
            addCriterion(ISysEventLogDAO.EventSourceId + " is null");

            return this;
        }

        public Criteria andEventSourceIdIsNotNull() {
            addCriterion(ISysEventLogDAO.EventSourceId + " is not null");

            return this;
        }

        public Criteria andEventSourceIdIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventSourceId + " is not null AND " +
                ISysEventLogDAO.EventSourceId + " <> ''");

            return this;
        }

        public Criteria andEventSourceIdIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventSourceId + " is null OR " +
                ISysEventLogDAO.EventSourceId + " = '')");

            return this;
        }

        public Criteria andEventSourceIdEqualTo(long value) {
            return andEventSourceIdEqualTo(Long.valueOf(value));
        }

        public Criteria andEventSourceIdEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " = ", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdNotEqualTo(long value) {
            return andEventSourceIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andEventSourceIdNotEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " <>", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdNotEqualToOrIsNull(long value) {
            return andEventSourceIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andEventSourceIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " is null OR " +
                ISysEventLogDAO.EventSourceId + " <>", value, "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdGreaterThan(long value) {
            return andEventSourceIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andEventSourceIdGreaterThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " >", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdGreaterThanOrEqualTo(long value) {
            return andEventSourceIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventSourceIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " >=", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdLessThan(long value) {
            return andEventSourceIdLessThan(Long.valueOf(value));
        }

        public Criteria andEventSourceIdLessThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " <", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdLessThanOrEqualTo(long value) {
            return andEventSourceIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventSourceIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventSourceId + " <=", value,
                "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventSourceId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventSourceIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdIn(long[] values) {
            if (values.length == 1) {
                return andEventSourceIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " in", values,
                    "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdNotIn(long[] values) {
            if (values.length == 1) {
                return andEventSourceIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " not in", values,
                    "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventSourceIdEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " in", values,
                    "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventSourceIdNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " not in", values,
                    "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventSourceIdEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " in",
                    Arrays.asList(values), "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventSourceIdNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventSourceId + " not in",
                    Arrays.asList(values), "eventSourceId");

                return this;
            }
        }

        public Criteria andEventSourceIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventSourceIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventSourceId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventSourceIdBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventSourceId + " between", value1,
                value2, "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventSourceId + " between", value1,
                value2, "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdNotBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventSourceId + " not between",
                value1, value2, "eventSourceId");

            return this;
        }

        public Criteria andEventSourceIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventSourceId + " not between",
                value1, value2, "eventSourceId");

            return this;
        }

        public Criteria andEventTypeCodeIsNull() {
            addCriterion(ISysEventLogDAO.EventTypeCode + " is null");

            return this;
        }

        public Criteria andEventTypeCodeIsNotNull() {
            addCriterion(ISysEventLogDAO.EventTypeCode + " is not null");

            return this;
        }

        public Criteria andEventTypeCodeIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventTypeCode + " is not null AND " +
                ISysEventLogDAO.EventTypeCode + " <> ''");

            return this;
        }

        public Criteria andEventTypeCodeIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventTypeCode + " is null OR " +
                ISysEventLogDAO.EventTypeCode + " = '')");

            return this;
        }

        public Criteria andEventTypeCodeEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " = ", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " <>", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " is null OR " +
                ISysEventLogDAO.EventTypeCode + " <>", value, "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " >", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " >=", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " <", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " <=", value,
                "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeCode);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeCodeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeCode + " like",
                buffer.toString(), "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeCode + " not like",
                buffer.toString(), "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeCodeEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeCode + " in", values,
                    "eventTypeCode");

                return this;
            }
        }

        public Criteria andEventTypeCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeCode + " not in", values,
                    "eventTypeCode");

                return this;
            }
        }

        public Criteria andEventTypeCodeIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeCodeEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeCode + " in",
                    Arrays.asList(values), "eventTypeCode");

                return this;
            }
        }

        public Criteria andEventTypeCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeCodeNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeCode + " not in",
                    Arrays.asList(values), "eventTypeCode");

                return this;
            }
        }

        public Criteria andEventTypeCodeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeCodeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeCodeBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " between", value1,
                value2, "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeCodeNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventTypeCode + " not between",
                value1, value2, "eventTypeCode");

            return this;
        }

        public Criteria andEventTypeNameIsNull() {
            addCriterion(ISysEventLogDAO.EventTypeName + " is null");

            return this;
        }

        public Criteria andEventTypeNameIsNotNull() {
            addCriterion(ISysEventLogDAO.EventTypeName + " is not null");

            return this;
        }

        public Criteria andEventTypeNameIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventTypeName + " is not null AND " +
                ISysEventLogDAO.EventTypeName + " <> ''");

            return this;
        }

        public Criteria andEventTypeNameIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventTypeName + " is null OR " +
                ISysEventLogDAO.EventTypeName + " = '')");

            return this;
        }

        public Criteria andEventTypeNameEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " = ", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " <>", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " is null OR " +
                ISysEventLogDAO.EventTypeName + " <>", value, "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " >", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " >=", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " <", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeName + " <=", value,
                "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeName + " like",
                buffer.toString(), "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeName + " not like",
                buffer.toString(), "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeNameEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeName + " in", values,
                    "eventTypeName");

                return this;
            }
        }

        public Criteria andEventTypeNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeNameNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeName + " not in", values,
                    "eventTypeName");

                return this;
            }
        }

        public Criteria andEventTypeNameIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeNameEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeName + " in",
                    Arrays.asList(values), "eventTypeName");

                return this;
            }
        }

        public Criteria andEventTypeNameNotIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeNameNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeName + " not in",
                    Arrays.asList(values), "eventTypeName");

                return this;
            }
        }

        public Criteria andEventTypeNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeNameBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventTypeName + " between", value1,
                value2, "eventTypeName");

            return this;
        }

        public Criteria andEventTypeNameNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventTypeName + " not between",
                value1, value2, "eventTypeName");

            return this;
        }

        public Criteria andEventTypeStatusIsNull() {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " is null");

            return this;
        }

        public Criteria andEventTypeStatusIsNotNull() {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " is not null");

            return this;
        }

        public Criteria andEventTypeStatusIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " is not null AND " +
                ISysEventLogDAO.EventTypeStatus + " <> ''");

            return this;
        }

        public Criteria andEventTypeStatusIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventTypeStatus +
                " is null OR " + ISysEventLogDAO.EventTypeStatus + " = '')");

            return this;
        }

        public Criteria andEventTypeStatusEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " = ", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeStatusNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " <>", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " is null OR " +
                ISysEventLogDAO.EventTypeStatus + " <>", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeStatusGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " >", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeStatusGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " >=", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeStatusLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " <", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventTypeStatusLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " <=", value,
                "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventTypeStatus);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventTypeStatusLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeStatus + " like",
                buffer.toString(), "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventTypeStatus + " not like",
                buffer.toString(), "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeStatusEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeStatus + " in", values,
                    "eventTypeStatus");

                return this;
            }
        }

        public Criteria andEventTypeStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventTypeStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventTypeStatus + " not in",
                    values, "eventTypeStatus");

                return this;
            }
        }

        public Criteria andEventTypeStatusIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeStatusEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeStatus + " in",
                    Arrays.asList(values), "eventTypeStatus");

                return this;
            }
        }

        public Criteria andEventTypeStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andEventTypeStatusNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventTypeStatus + " not in",
                    Arrays.asList(values), "eventTypeStatus");

                return this;
            }
        }

        public Criteria andEventTypeStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventTypeStatusBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " between", value1,
                value2, "eventTypeStatus");

            return this;
        }

        public Criteria andEventTypeStatusNotBetween(String value1,
            String value2) {
            addCriterion(ISysEventLogDAO.EventTypeStatus + " not between",
                value1, value2, "eventTypeStatus");

            return this;
        }

        public Criteria andEventDomainIdIsNull() {
            addCriterion(ISysEventLogDAO.EventDomainId + " is null");

            return this;
        }

        public Criteria andEventDomainIdIsNotNull() {
            addCriterion(ISysEventLogDAO.EventDomainId + " is not null");

            return this;
        }

        public Criteria andEventDomainIdIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventDomainId + " is not null AND " +
                ISysEventLogDAO.EventDomainId + " <> ''");

            return this;
        }

        public Criteria andEventDomainIdIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventDomainId + " is null OR " +
                ISysEventLogDAO.EventDomainId + " = '')");

            return this;
        }

        public Criteria andEventDomainIdEqualTo(long value) {
            return andEventDomainIdEqualTo(Long.valueOf(value));
        }

        public Criteria andEventDomainIdEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " = ", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdNotEqualTo(long value) {
            return andEventDomainIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andEventDomainIdNotEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " <>", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdNotEqualToOrIsNull(long value) {
            return andEventDomainIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andEventDomainIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " is null OR " +
                ISysEventLogDAO.EventDomainId + " <>", value, "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdGreaterThan(long value) {
            return andEventDomainIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andEventDomainIdGreaterThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " >", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdGreaterThanOrEqualTo(long value) {
            return andEventDomainIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventDomainIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " >=", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdLessThan(long value) {
            return andEventDomainIdLessThan(Long.valueOf(value));
        }

        public Criteria andEventDomainIdLessThan(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " <", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdLessThanOrEqualTo(long value) {
            return andEventDomainIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andEventDomainIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(ISysEventLogDAO.EventDomainId + " <=", value,
                "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdIn(long[] values) {
            if (values.length == 1) {
                return andEventDomainIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " in", values,
                    "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdNotIn(long[] values) {
            if (values.length == 1) {
                return andEventDomainIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " not in", values,
                    "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventDomainIdEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " in", values,
                    "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andEventDomainIdNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " not in", values,
                    "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventDomainIdEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " in",
                    Arrays.asList(values), "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andEventDomainIdNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainId + " not in",
                    Arrays.asList(values), "eventDomainId");

                return this;
            }
        }

        public Criteria andEventDomainIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainIdBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventDomainId + " between", value1,
                value2, "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventDomainId + " between", value1,
                value2, "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdNotBetween(long value1, long value2) {
            addCriterion(ISysEventLogDAO.EventDomainId + " not between",
                value1, value2, "eventDomainId");

            return this;
        }

        public Criteria andEventDomainIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(ISysEventLogDAO.EventDomainId + " not between",
                value1, value2, "eventDomainId");

            return this;
        }

        public Criteria andEventDomainCodeIsNull() {
            addCriterion(ISysEventLogDAO.EventDomainCode + " is null");

            return this;
        }

        public Criteria andEventDomainCodeIsNotNull() {
            addCriterion(ISysEventLogDAO.EventDomainCode + " is not null");

            return this;
        }

        public Criteria andEventDomainCodeIsNotEmpty() {
            addCriterion(ISysEventLogDAO.EventDomainCode + " is not null AND " +
                ISysEventLogDAO.EventDomainCode + " <> ''");

            return this;
        }

        public Criteria andEventDomainCodeIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.EventDomainCode +
                " is null OR " + ISysEventLogDAO.EventDomainCode + " = '')");

            return this;
        }

        public Criteria andEventDomainCodeEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " = ", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainCodeNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " <>", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " is null OR " +
                ISysEventLogDAO.EventDomainCode + " <>", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainCodeGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " >", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainCodeGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " >=", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainCodeLessThan(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " <", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEventDomainCodeLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " <=", value,
                "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.EventDomainCode);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEventDomainCodeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventDomainCode + " like",
                buffer.toString(), "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.EventDomainCode + " not like",
                buffer.toString(), "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andEventDomainCodeEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventDomainCode + " in", values,
                    "eventDomainCode");

                return this;
            }
        }

        public Criteria andEventDomainCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andEventDomainCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.EventDomainCode + " not in",
                    values, "eventDomainCode");

                return this;
            }
        }

        public Criteria andEventDomainCodeIn(String[] values) {
            if (values.length == 1) {
                return andEventDomainCodeEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainCode + " in",
                    Arrays.asList(values), "eventDomainCode");

                return this;
            }
        }

        public Criteria andEventDomainCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andEventDomainCodeNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.EventDomainCode + " not in",
                    Arrays.asList(values), "eventDomainCode");

                return this;
            }
        }

        public Criteria andEventDomainCodeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainCodeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEventDomainCodeBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " between", value1,
                value2, "eventDomainCode");

            return this;
        }

        public Criteria andEventDomainCodeNotBetween(String value1,
            String value2) {
            addCriterion(ISysEventLogDAO.EventDomainCode + " not between",
                value1, value2, "eventDomainCode");

            return this;
        }

        public Criteria andOperatorNameIsNull() {
            addCriterion(ISysEventLogDAO.OperatorName + " is null");

            return this;
        }

        public Criteria andOperatorNameIsNotNull() {
            addCriterion(ISysEventLogDAO.OperatorName + " is not null");

            return this;
        }

        public Criteria andOperatorNameIsNotEmpty() {
            addCriterion(ISysEventLogDAO.OperatorName + " is not null AND " +
                ISysEventLogDAO.OperatorName + " <> ''");

            return this;
        }

        public Criteria andOperatorNameIsEmpty() {
            addCriterion("(" + ISysEventLogDAO.OperatorName + " is null OR " +
                ISysEventLogDAO.OperatorName + " = '')");

            return this;
        }

        public Criteria andOperatorNameEqualTo(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " = ", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andOperatorNameNotEqualTo(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " <>", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameNotEqualToOrIsNull(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " is null OR " +
                ISysEventLogDAO.OperatorName + " <>", value, "operatorName");

            return this;
        }

        public Criteria andOperatorNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andOperatorNameGreaterThan(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " >", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andOperatorNameGreaterThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " >=", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andOperatorNameLessThan(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " <", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andOperatorNameLessThanOrEqualTo(String value) {
            addCriterion(ISysEventLogDAO.OperatorName + " <=", value,
                "operatorName");

            return this;
        }

        public Criteria andOperatorNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(ISysEventLogDAO.OperatorName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andOperatorNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andOperatorNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.OperatorName + " like",
                buffer.toString(), "operatorName");

            return this;
        }

        public Criteria andOperatorNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(ISysEventLogDAO.OperatorName + " not like",
                buffer.toString(), "operatorName");

            return this;
        }

        public Criteria andOperatorNameIn(List<String> values) {
            if (values.size() == 1) {
                return andOperatorNameEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.OperatorName + " in", values,
                    "operatorName");

                return this;
            }
        }

        public Criteria andOperatorNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andOperatorNameNotEqualTo(values.get(0));
            } else {
                addCriterion(ISysEventLogDAO.OperatorName + " not in", values,
                    "operatorName");

                return this;
            }
        }

        public Criteria andOperatorNameIn(String[] values) {
            if (values.length == 1) {
                return andOperatorNameEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.OperatorName + " in",
                    Arrays.asList(values), "operatorName");

                return this;
            }
        }

        public Criteria andOperatorNameNotIn(String[] values) {
            if (values.length == 1) {
                return andOperatorNameNotEqualTo(values[0]);
            } else {
                addCriterion(ISysEventLogDAO.OperatorName + " not in",
                    Arrays.asList(values), "operatorName");

                return this;
            }
        }

        public Criteria andOperatorNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andOperatorNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(ISysEventLogDAO.OperatorName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andOperatorNameBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.OperatorName + " between", value1,
                value2, "operatorName");

            return this;
        }

        public Criteria andOperatorNameNotBetween(String value1, String value2) {
            addCriterion(ISysEventLogDAO.OperatorName + " not between", value1,
                value2, "operatorName");

            return this;
        }
    }
}
